Course: Python Training
Topic: Exploring Type Hints, Annotations, and Modern Python Syntax
Course Link: Python Training Course at JustAcademy
Demo Link: Register for a Course Demo
Official Website: JustAcademy
Python is a dynamically typed programming language, which means that variables do not need explicit type declarations before they can hold values. However, as Python applications grow, understanding what type of data a function expects and returns becomes increasingly important.
Type hints, annotations, and modern Python syntax help developers write code that is easier to understand, maintain, test, and refactor. They communicate the expected types of variables, function parameters, return values, collections, and custom objects.
Python supports annotations directly in its syntax, while tools such as static type checkers and IDEs can analyze these annotations to identify potential mistakes before a program runs.
Modern Python also provides convenient syntax for union types, generic collections, type aliases, pattern matching, assignment expressions, f-strings, and other language features that improve code readability.
Any, Literal, TypedDict, Protocol, and Annotated.Python uses dynamic typing because a variable name can refer to objects of different types at different points during program execution.
value = 100
print(value)
value = "Python"
print(value)
value = [10, 20, 30]
print(value)Output:
100
Python
[10, 20, 30]The same variable name refers to an integer, a string, and then a list. Python permits these assignments because variable names are not permanently restricted to one type.
Type hints help address these challenges without removing Python's dynamic nature.
A type hint is an annotation that communicates the expected type of a variable, function parameter, or return value. Type hints act as documentation and can be analyzed by compatible development tools.
age: int = 25
name: str = "Aarav"
price: float = 499.50
is_active: bool = True
print(name)
print(age)
print(price)
print(is_active)The annotations indicate that age is expected to be an integer, name a string, price a floating-point number, and is_active a Boolean value.
Functions are among the most useful places to add type hints because they define clear interfaces between different parts of a program.
def greet(name: str):
print(f"Hello, {name}!")
greet("Riya")The name: str annotation communicates that the function expects a string.
def add(a: int, b: int) -> int:
return a + b
result = add(10, 20)
print(result)The arrow syntax -> int indicates that the function is expected to return an integer.
def display_message(message: str) -> None:
print(message)
display_message("Welcome to Python")Use None as the return annotation when a function does not return a meaningful value.
def calculate_total(
price: float,
quantity: int,
discount: float = 0.0
) -> float:
subtotal = price * quantity
return subtotal - discount
total = calculate_total(250.0, 3, 50.0)
print(total)Output:
700.0The parameter annotations document the expected input types, and the return annotation documents the expected result type. The function still needs suitable validation if the values originate from untrusted sources.
Variable annotations can communicate the intended type of a variable even when an initial value is not assigned immediately.
username: str
score: int
email: str | None
username = "sam"
score = 95
email = None
print(username, score, email)Variable annotations are particularly helpful for class attributes, module-level variables, and variables that are initialized later.
class Product:
name: str
price: float
in_stock: bool
def __init__(
self,
name: str,
price: float,
in_stock: bool
) -> None:
self.name = name
self.price = price
self.in_stock = in_stock
product = Product("Keyboard", 1499.0, True)
print(product.name)
print(product.price)Annotations make the expected structure of the Product class easier to understand.
| Type Hint | Purpose | Example |
|---|---|---|
int |
Whole numbers | count: int = 10 |
float |
Floating-point numbers | price: float = 19.99 |
str |
Text | name: str = "Mira" |
bool |
Boolean values | active: bool = True |
bytes |
Binary data | data: bytes = b"abc" |
None |
No meaningful value | result: None = None |
object |
General Python object type | item: object = "text" |
Any |
Disables many static type restrictions for that value | from typing import Any |
Use the most specific useful type rather than defaulting to Any for every variable. More precise annotations allow type checkers to detect more mistakes.
Modern Python allows built-in collection types to be parameterized directly. This syntax is available in Python 3.9 and later.
numbers: list[int] = [10, 20, 30]
names: list[str] = ["Asha", "Dev", "Mira"]
def calculate_sum(values: list[int]) -> int:
return sum(values)
print(calculate_sum(numbers))coordinates: tuple[int, int] = (10, 20)
person: tuple[str, int] = ("Asha", 25)
print(coordinates)
print(person)A tuple with specific element types and a fixed length can be annotated with each position's type. To represent a tuple of any length containing integers, use tuple[int, ...].
scores: tuple[int, ...] = (80, 90, 95, 88)unique_ids: set[int] = {101, 102, 103}
tags: set[str] = {"python", "backend", "api"}student_marks: dict[str, int] = {
"Asha": 85,
"Dev": 92,
"Mira": 88
}
def get_mark(
marks: dict[str, int],
student: str
) -> int | None:
return marks.get(student)
print(get_mark(student_marks, "Dev"))Output:
92In dict[str, int], the first type describes dictionary keys and the second describes dictionary values.
A union type indicates that a value may belong to one of several types. Modern Python supports the | operator for this purpose, beginning with Python 3.10.
def format_identifier(identifier: int | str) -> str:
return f"ID: {identifier}"
print(format_identifier(101))
print(format_identifier("EMP-202"))Output:
ID: 101
ID: EMP-202The parameter can be an integer or a string according to the annotation.
# Modern syntax: Python 3.10+
def process(value: int | str) -> str:
return str(value)
# Older alternative
from typing import Union
def process_legacy(value: Union[int, str]) -> str:
return str(value)Use the modern pipe syntax when your project's minimum Python version is 3.10 or newer. Use typing.Union when supporting older Python versions requires it.
Many functions may return a value or return None when a result is unavailable. In modern Python, str | None expresses this clearly.
def find_username(user_id: int) -> str | None:
users: dict[int, str] = {
1: "Asha",
2: "Dev"
}
return users.get(user_id)
username = find_username(3)
if username is not None:
print(username.upper())
else:
print("User not found")Output:
User not foundBefore using a value that may be None, check that it is not None. This is important because calling a string method on None would cause an error.
from typing import Optional
def get_email(user_id: int) -> Optional[str]:
if user_id == 1:
return "[email protected]"
return NoneOptional[str] means the value may be a string or None. It does not mean that the argument can simply be omitted from the function call.
Annotations are the syntax Python uses to attach metadata to function parameters, return values, and variables. Type hints are the most common use of annotations, but annotations can also represent other kinds of metadata.
def multiply(a: int, b: int) -> int:
return a * b
print(multiply.__annotations__)In conventional Python versions and annotation configurations, the annotations dictionary for this function contains information about a, b, and the return value.
Typical output:
{'a': <class 'int'>,
'b': <class 'int'>,
'return': <class 'int'>}Exact runtime representation can vary with Python version and annotation evaluation behavior.
from typing import get_type_hints
def calculate_area(width: float, height: float) -> float:
return width * height
hints = get_type_hints(calculate_area)
print(hints)get_type_hints() is often more useful than directly inspecting __annotations__, because it resolves supported forward references and processes annotation information. Resolving annotations can evaluate expressions, so do not resolve annotations from untrusted code indiscriminately.
Python does not ordinarily reject a value simply because it conflicts with a type hint. The annotation communicates an expectation, but the language does not automatically enforce that expectation on every function call or assignment.
def greet(name: str) -> str:
return "Hello " + name
print(greet("Riya"))
print(greet(123))The second call raises a TypeError because string concatenation with an integer is not supported in this example. The error results from the operation inside the function, not from Python enforcing the annotation.
def parse_age(value: object) -> int:
if isinstance(value, bool):
raise ValueError("Age must be an integer, not a Boolean")
if isinstance(value, int) and value >= 0:
return value
raise ValueError("Age must be a non-negative integer")
print(parse_age(25))This example uses runtime checks to validate a value. Validation is especially important when handling form submissions, JSON payloads, environment variables, files, and database records.
Any and object may appear similar, but they have different meanings for static type checking.
| Feature | Any | object |
|---|---|---|
| Meaning | Type checker treats the value as dynamically typed. | Value may be any Python object. |
| Operations | Many operations are accepted by the type checker. | Only operations valid for the general object type are accepted without narrowing. |
| Safety | Can hide type-related mistakes. | Encourages checks before type-specific operations. |
| Typical use | Gradually typing dynamic or external interfaces. | Accepting unknown values while preserving type-checking discipline. |
from typing import Any
dynamic_value: Any = "Python"
print(dynamic_value.upper())
unknown_value: object = "Python"
if isinstance(unknown_value, str):
print(unknown_value.upper())Use object when the value is genuinely unknown and you want to narrow its type through checks. Use Any when intentionally accepting dynamic typing at a particular boundary.
A type alias gives a descriptive name to a type expression. Aliases can simplify complicated annotations and make domain-specific concepts easier to recognize.
UserId = int
Price = float
Coordinates = tuple[float, float]
def locate_user(user_id: UserId) -> Coordinates:
return (19.07, 72.87)
location = locate_user(101)
print(location)A simple assignment creates a useful alias for documentation and type checking, although it does not create a new runtime type or prevent an integer from being used where another integer is expected.
from typing import TypeAlias
JsonScalar: TypeAlias = str | int | float | bool | None
JsonValue: TypeAlias = (
JsonScalar
| list["JsonValue"]
| dict[str, "JsonValue"]
)For Python 3.12 and later, the type statement provides modern type-alias syntax:
# Python 3.12+
type UserId = int
type Coordinates = tuple[float, float]
type JsonScalar = str | int | float | bool | NoneChoose syntax compatible with the project's minimum supported Python version.
Literal restricts an annotation to a specific set of values. It is useful when a function accepts only predefined modes, commands, statuses, or configuration options.
from typing import Literal
Status = Literal["pending", "approved", "rejected"]
def update_status(status: Status) -> str:
return f"Status updated to {status}"
print(update_status("approved"))Output:
Status updated to approvedA static type checker can flag calls using values outside the declared choices. However, Literal does not independently validate untrusted runtime input.
from typing import Literal
def create_report(
format_type: Literal["pdf", "csv", "json"]
) -> str:
return f"Creating {format_type.upper()} report"
print(create_report("csv"))This annotation communicates that only the three listed formats are supported.
A normal dictionary type such as dict[str, object] describes the types of keys and values broadly. TypedDict provides a way to describe dictionaries with particular key names and expected value types.
from typing import TypedDict
class Employee(TypedDict):
employee_id: int
name: str
department: str
active: bool
employee: Employee = {
"employee_id": 101,
"name": "Riya",
"department": "Engineering",
"active": True
}
print(employee["name"])
print(employee["department"])Output:
Riya
EngineeringTypedDict primarily supports static analysis. It does not automatically validate a dictionary at runtime.
Python commonly uses duck typing: an object is useful when it provides the required behavior. A Protocol allows that expectation to be expressed as a type without requiring a class to inherit from a particular base class.
from typing import Protocol
class Notifier(Protocol):
def send(self, message: str) -> None:
...
class EmailNotifier:
def send(self, message: str) -> None:
print(f"Email sent: {message}")
class ConsoleNotifier:
def send(self, message: str) -> None:
print(f"Console notification: {message}")
def notify_user(
notifier: Notifier,
message: str
) -> None:
notifier.send(message)
notify_user(EmailNotifier(), "Your report is ready")
notify_user(ConsoleNotifier(), "Your report is ready")Output:
Email sent: Your report is ready
Console notification: Your report is readyBoth classes provide the required send() method. A compatible static type checker can recognize that they satisfy the protocol's structural requirements.
Annotated lets developers attach additional metadata to a type hint. This can be useful when a framework or application needs extra information about a value, such as a validation rule or display label.
from typing import Annotated
UserName = Annotated[str, "Must contain a user display name"]
def create_profile(name: UserName) -> str:
return f"Profile created for {name}"
print(create_profile("Asha"))The metadata string communicates extra information, but Python does not automatically enforce the rule. A framework or custom validation function would need to interpret and apply the metadata.
from typing import Annotated
PositiveNumber = Annotated[int, "Must be greater than zero"]
def validate_quantity(quantity: PositiveNumber) -> int:
if quantity <= 0:
raise ValueError("Quantity must be positive")
return quantity
print(validate_quantity(5))The explicit condition performs the validation; the annotation documents the intended constraint.
Generics help describe reusable functions and classes that work with multiple types while preserving relationships between input and output values.
from typing import TypeVar
T = TypeVar("T")
def first_item(items: list[T]) -> T:
return items[0]
number = first_item([10, 20, 30])
name = first_item(["Asha", "Dev", "Mira"])
print(number)
print(name)The type variable T allows a type checker to infer that the function returns an element of the same type as the list elements.
# Python 3.12+
def first_item[T](items: list[T]) -> T:
return items[0]
print(first_item([100, 200, 300]))
print(first_item(["Python", "SQL"]))Python 3.12 introduced new type-parameter syntax for generic functions and classes. Older projects can continue using TypeVar.
def safe_first_item[T](items: list[T]) -> T | None:
if not items:
return None
return items[0]
print(safe_first_item([]))
print(safe_first_item([10, 20]))Output:
None
10The return annotation makes it clear that the function may not have an item to return.
F-strings provide a readable way to insert expressions into strings. They were introduced in Python 3.6 and are widely used for messages, logs, reports, and formatted output.
name = "Asha"
score = 94
message = f"{name} scored {score} marks."
print(message)Output:
Asha scored 94 marks.price = 1234.5678
print(f"Price: {price:.2f}")
print(f"Percentage: {0.875:.1%}")Output:
Price: 1234.57
Percentage: 87.5%total = 150
tax = 18
print(f"{total=}, {tax=}")Output:
total=150, tax=18The debugging form {variable=} is available in Python 3.8 and later.
The assignment expression operator, also called the walrus operator, assigns a value to a variable as part of an expression. It was introduced in Python 3.8.
numbers = [12, 18, 25, 30]
if (count := len(numbers)) > 3:
print(f"The list contains {count} items")Output:
The list contains 4 itemsdata = ["Python", "SQL", "", "Power BI"]
while (item := data.pop(0)) != "":
print(item)Output:
Python
SQLThe loop stops when it encounters the empty string. In real applications, use assignment expressions only when they improve clarity; ordinary assignments may be easier to read in more complex situations.
Structural pattern matching was introduced in Python 3.10 through the match and case statements. It can make code that handles multiple known data shapes or commands easier to organize.
def describe_status(status: str) -> str:
match status:
case "pending":
return "Waiting for approval"
case "approved":
return "Request approved"
case "rejected":
return "Request rejected"
case _:
return "Unknown status"
print(describe_status("approved"))
print(describe_status("pending"))Output:
Request approved
Waiting for approvaldef describe_point(point: tuple[int, int]) -> str:
match point:
case (0, 0):
return "Origin"
case (x, 0):
return f"On the x-axis at {x}"
case (0, y):
return f"On the y-axis at {y}"
case (x, y):
return f"Point at ({x}, {y})"
print(describe_point((0, 5)))
print(describe_point((3, 4)))Output:
On the y-axis at 5
Point at (3, 4)Type hints document the expected input shape, while pattern matching determines which case applies at runtime.
Python provides several concise patterns for creating and transforming collections. These are useful for readable data processing and everyday application development.
numbers = [1, 2, 3, 4, 5]
squares: dict[int, int] = {
number: number ** 2
for number in numbers
}
print(squares)Output:
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}words = ["python", "sql", "python", "api"]
unique_words: set[str] = {word for word in words}
print(unique_words)A set removes duplicate values, but its display order should not be treated as a guaranteed ordering contract.
first, second, *remaining = [10, 20, 30, 40, 50]
print(first)
print(second)
print(remaining)Output:
10
20
[30, 40, 50]Unpacking can make data transformations concise, but ensure that the input structure matches the expected number and arrangement of values.
Python's standard library includes useful tools that make modern application code safer and clearer.
from pathlib import Path
project_dir = Path("project")
data_file = project_dir / "data.csv"
print(data_file)
print(data_file.suffix)Output:
project/data.csv
.csvThe exact path display can vary by operating system. The pathlib module provides an object-oriented interface for working with filesystem paths.
from pathlib import Path
def read_text_file(path: Path) -> str:
return path.read_text(encoding="utf-8")
# Example:
# content = read_text_file(Path("notes.txt"))The annotation documents the expected input, but the function can still raise errors if the file does not exist or cannot be read.
Type narrowing allows a type checker to determine that a value has a more specific type after a condition. It is especially important when using union types.
def normalize(value: int | str) -> str:
if isinstance(value, int):
return f"Number: {value}"
return value.strip().title()
print(normalize(100))
print(normalize(" python training "))Output:
Number: 100
Python TrainingAfter the isinstance(value, int) check, a compatible type checker can understand that the value is an integer in that branch. In the remaining branch, the type is narrowed to a string for this union.
A forward reference is a type reference to a class or type that has not yet been defined at the point where the annotation is written. Forward references are useful for linked structures, tree nodes, and recursive data models.
class Category:
def __init__(
self,
name: str,
parent: "Category | None" = None
) -> None:
self.name = name
self.parent = parent
root = Category("Technology")
child = Category("Programming", root)
print(child.name)
print(child.parent.name)Output:
Programming
TechnologyString annotations can be useful for forward references, especially in code supporting older Python versions. Another option in supported Python versions is to use from __future__ import annotations, while remembering that annotation evaluation and representation can vary by Python version.
The dataclasses module uses annotated fields to help generate methods such as __init__() and __repr__(). It is particularly useful for classes whose primary purpose is to store structured data.
from dataclasses import dataclass
@dataclass
class Course:
title: str
duration_hours: int
fee: float
is_online: bool = True
course = Course(
title="Python Programming",
duration_hours=40,
fee=9999.0
)
print(course)
print(course.title)Output:
Course(title='Python Programming', duration_hours=40, fee=9999.0, is_online=True)
Python ProgrammingDataclasses use annotations to identify fields, but they do not automatically enforce all declared types. Use explicit validation or a suitable validation library when strict runtime checking is required.
A static type checker examines source code and its annotations to report potential inconsistencies without needing to execute every code path. Common tools include mypy and Pyright.
def calculate_total(price: float, quantity: int) -> float:
return price * quantity
total = calculate_total(100.0, 3)
print(total)python -m pip install mypypython -m mypy app.pyThe tool analyzes annotations and expressions to identify issues such as incorrect argument types, incompatible return values, and invalid operations.
def calculate_total(price: float, quantity: int) -> float:
return price * quantity
total = calculate_total("100", 3)A type checker can report that the first argument is a string even though the function expects a float.
Type-checker results depend on the tool, its configuration, and the completeness of the annotations. Static analysis complements, rather than replaces, tests and runtime validation.
Modern syntax is not available in every Python release. Developers should check the project's minimum supported Python version before adopting newer features.
| Feature | Minimum Python Version | Purpose |
|---|---|---|
| F-strings | 3.6 | Readable string interpolation |
Assignment expressions := |
3.8 | Assign a value within an expression |
Built-in collection generics such as list[int] |
3.9 | Annotate collection element types |
Union syntax such as int | str |
3.10 | Express alternative types |
match and case |
3.10 | Structural pattern matching |
Self in the typing module |
3.11 | Annotate methods returning the current class type |
New generic parameter syntax and type statements |
3.12 | Modern generic declarations and type aliases |
When working in a team, agree on the supported Python version and configure development tools to use that target. This prevents code from accidentally relying on syntax that is unavailable in production.
| Mistake | Why It Is a Problem | Recommended Solution |
|---|---|---|
| Assuming hints enforce types at runtime | Python does not generally enforce annotations automatically. | Validate untrusted data explicitly. |
Using Any everywhere |
Weakens the usefulness of static analysis. | Prefer specific types or object where appropriate. |
Ignoring possible None values |
Can cause runtime attribute or operation errors. | Check for None before using the value. |
| Using new syntax on an older Python version | The code may fail to parse or import. | Check the minimum supported version. |
| Incorrect collection annotations | Can make the code contract misleading and trigger type-checker errors. | Match the annotation to the intended collection structure. |
Expecting TypedDict to validate data |
It is mainly a static typing construct. | Validate API and JSON data at runtime. |
| Using annotations without checking them | Incorrect annotations can mislead other developers. | Run a type checker and update annotations when behavior changes. |
| Making every annotation overly complicated | Reduces readability. | Use descriptive type aliases and smaller functions. |
type() or isinstance().list[str] and dict[str, int] where compatible with your Python version.| for union types in Python 3.10 and later.T | None and handle that case explicitly.Any.TypedDict for dictionary-shaped records and Protocol for behavior-based interfaces.This mini-project combines function annotations, collection types, union types, validation, and f-strings in a small student result application.
from typing import TypeAlias
StudentRecords: TypeAlias = dict[str, list[int]]
def validate_scores(scores: list[int]) -> None:
for score in scores:
if isinstance(score, bool) or not isinstance(score, int):
raise ValueError("Every score must be an integer")
if not 0 <= score <= 100:
raise ValueError("Scores must be between 0 and 100")
def calculate_average(scores: list[int]) -> float:
validate_scores(scores)
if not scores:
return 0.0
return sum(scores) / len(scores)
def find_student(
records: StudentRecords,
name: str
) -> list[int] | None:
return records.get(name)
def display_report(records: StudentRecords) -> None:
for name, scores in records.items():
average = calculate_average(scores)
print(
f"Student: {name} | "
f"Scores: {scores} | "
f"Average: {average:.2f}"
)
students: StudentRecords = {
"Asha": [85, 90, 92],
"Dev": [78, 82, 88],
"Mira": [95, 97, 93]
}
display_report(students)
result = find_student(students, "Dev")
if result is not None:
print(f"Dev's scores: {result}")
else:
print("Student not found")Student: Asha | Scores: [85, 90, 92] | Average: 89.00
Student: Dev | Scores: [78, 82, 88] | Average: 82.67
Student: Mira | Scores: [95, 97, 93] | Average: 95.00
Dev's scores: [78, 82, 88]StudentRecords demonstrates a type alias.list[int] describes lists of integer scores.-> None describes functions that return no meaningful result.list[int] | None describes a result that may be missing.validate_scores() performs runtime validation.Extension task: Add a function that returns the highest-scoring student, rejects empty score lists when calculating an average, and generates a pass/fail status using a threshold of 40 marks.
square(number: int) -> int that returns the square of a number.None if the product cannot be found.TypedDict representing a course with a title, duration, and fee.Literal to restrict a function to three report formats.None when the list is empty.Protocol for a service with a save() method.Annotated to document a positive integer and enforce it with explicit validation.Optional or Union approach.Answer: Type hints are annotations that communicate the expected types of variables, function parameters, and return values. They help documentation, IDEs, and static type checkers.
Answer: No. Python generally does not enforce type hints at runtime. Runtime validation must be implemented explicitly or provided by a framework or library.
Answer: An annotation is metadata attached using Python's annotation syntax. A type hint is an annotation used to express an expected type.
Answer: Use an arrow followed by the expected return type, such as def add(a: int, b: int) -> int:.
None mean in a return annotation?Answer: It indicates that a function does not return a meaningful value.
Answer: A union type represents a value that may be one of several types, such as int | str in Python 3.10 and later.
Any and object?Answer: Any allows a type checker to accept many operations without detailed checking. object represents a general Python object and usually requires type narrowing before type-specific operations.
Answer: A type alias provides another descriptive name for a type expression. Python 3.12 introduced the type statement for declaring aliases.
Answer: It describes dictionaries with specific keys and corresponding value types, which is useful for structured records and JSON-like data.
Answer: A protocol describes the methods and attributes an object should provide. Compatible objects can satisfy the protocol without explicitly inheriting from it.
Answer: Literal restricts an annotated value to a predefined set of literal values, which helps type checkers validate choices such as statuses or modes.
Answer: The := operator assigns a value as part of an expression. It was introduced in Python 3.8.
Answer: It is a feature introduced in Python 3.10 that uses match and case to select behavior based on the structure or value of data.
Answer: They detect potential type inconsistencies, improve refactoring confidence, and make large codebases easier to maintain without requiring every execution path to run first.
Answer: Type narrowing uses conditions such as isinstance() to establish that a value has a more specific type in a particular branch.
name: str for variable annotations.def function(value: int) -> int: for function annotations.list[str], tuple[int, ...], and dict[str, int] for common collections.int | str for union types in Python 3.10 and later.T | None when a value may be missing.Any sparingly and prefer precise annotations.TypedDict for fixed dictionary structures.Protocol to describe behavior-based interfaces.Literal for a fixed set of allowed values.get_type_hints() when resolved type information is needed.Type hints, annotations, and modern Python syntax help developers create readable, maintainable, and more reliable applications. Type hints make function contracts explicit, collection annotations clarify data structures, and advanced tools such as TypedDict, Protocol, Literal, and generic types support stronger static analysis.
Modern syntax such as union types, f-strings, assignment expressions, and structural pattern matching can also simplify common programming tasks when used appropriately. The most effective approach is to combine clear annotations with runtime validation, automated tests, and a consistent static type-checking workflow.
Practice these techniques in small functions first, then apply them to larger projects such as API services, data-processing tools, automation scripts, and object-oriented applications.
